package com.smart.community.property.service.impl;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.smart.community.commons.cache.DataScopeInfo;
import com.smart.community.commons.dto.property.PropertyCompanyQueryDTO;
import com.smart.community.commons.entity.property.PropertyCompany;
import com.smart.community.commons.entity.property.PropertyCompanyCommunity;
import com.smart.community.commons.entity.property.UserPropertyCompany;
import com.smart.community.commons.enums.RoleCodeEnum;
import com.smart.community.commons.enums.SystemStatusEnum;
import com.smart.community.commons.result.PageResult;
import com.smart.community.commons.result.Result;
import com.smart.community.commons.utils.SecurityUtils;
import com.smart.community.feign.region.dto.RegionDTO;
import com.smart.community.feign.region.service.RegionDataFeignService;
import com.smart.community.feign.user.dto.UserDTO;
import com.smart.community.feign.user.service.UserFeignService;
import com.smart.community.property.dto.PropertyCompanyAuditDTO;
import com.smart.community.property.dto.PropertyCompanyDTO;
import com.smart.community.property.mapper.PropertyCompanyMapper;
import com.smart.community.property.mapper.UserPropertyCompanyMapper;
import com.smart.community.property.service.DataScopeService;
import com.smart.community.property.service.IPropertyCompanyCommunityService;
import com.smart.community.property.service.IPropertyCompanyService;
import com.smart.community.property.service.PropertyCompanyPermissionCacheService;
import com.smart.community.property.vo.PropertyCompanyVO;

import io.seata.spring.annotation.GlobalTransactional;
import lombok.extern.slf4j.Slf4j;

/**
 * 物业公司服务实现类
 * 
 * 严格按照《Java后端SpringBoot代码开发规范.md》Service层规范实现：
 * - 异常处理规范：使用log.warn记录业务异常，使用log.error记录系统异常
 * - 参数验证：完善的参数验证和错误提示
 * - 业务逻辑：清晰的业务逻辑和错误处理
 * - 性能优化：合理的查询优化和缓存策略
 * - 生产环境标准：符合企业级应用的高可用性、可监控性、可维护性、可扩展性要求
 * 
 * @author Wu.Liang
 * @since 2025-06-29
 * @version 2.0.0 - 生产环境标准优化
 */
@Slf4j
@Service
public class PropertyCompanyServiceImpl extends ServiceImpl<PropertyCompanyMapper, PropertyCompany>
		implements IPropertyCompanyService {
	@Autowired
	private RegionDataFeignService regionDataFeignClient;
	@Autowired
	private UserFeignService userFeignService;
	@Autowired
	private UserPropertyCompanyMapper userPropertyCompanyMapper;
	@Autowired
	private PropertyCompanyPermissionCacheService permissionCacheService;
	@Autowired
	private DataScopeService dataScopeService;
	@Autowired
	private IPropertyCompanyCommunityService propertyCompanyCommunityService;

	@Override
	public Result<PropertyCompanyVO> getPropertyCompany(Long id) {
		try {
			// 参数验证
			if (id == null) {
				log.warn("查询物业公司详情失败，ID不能为空");
				return Result.fail("物业公司ID不能为空");
			}

			log.info("查询物业公司详情，ID：{}", id);
			PropertyCompany propertyCompany = this.getById(id);
			if (propertyCompany == null) {
				log.warn("物业公司不存在，ID：{}", id);
				return Result.fail("物业公司不存在");
			}

			PropertyCompanyVO vo = convertToVO(propertyCompany);
			log.info("查询物业公司详情成功，ID：{}", id);
			return Result.success(vo);
		} catch (Exception e) {
			log.error("查询物业公司详情失败，ID：{}", id, e);
			return Result.fail("查询失败");
		}
	}

	@Override
	public Result<PageResult<PropertyCompanyVO>> getPropertyCompanyList(PropertyCompanyQueryDTO queryDTO) {
		try {
			// 参数验证
			if (queryDTO == null) {
				log.warn("查询物业公司列表失败，查询参数不能为空");
				return Result.fail("查询参数不能为空");
			}

			log.info("查询物业公司列表，参数：{}", queryDTO);
			Long currentUserId = SecurityUtils.getCurrentUserId();
			log.info("当前用户ID：{}，开始权限检查", currentUserId);

			// 构建查询条件
			QueryWrapper<PropertyCompany> queryWrapper = buildQueryWrapper(queryDTO);

			// 添加数据权限过滤
			DataScopeInfo dataScopeInfo = dataScopeService.getCurrentUserDataScope();
			boolean isSuperAdmin = dataScopeInfo.isSuperAdmin();
			log.info("用户{}是否为超级管理员：{}", currentUserId, isSuperAdmin);

			if (!isSuperAdmin) {
				// 非超级管理员需要进行数据权限过滤
				List<Long> propertyCompanyIds = dataScopeInfo.getPropertyCompanyIds();
				log.info("用户{}的物业公司权限ID列表：{}", currentUserId, propertyCompanyIds);

				if (propertyCompanyIds == null || propertyCompanyIds.isEmpty()) {
					// 用户没有任何物业公司权限，返回空结果
					log.warn("用户{}没有物业公司权限，返回空结果", currentUserId);
					PageResult<PropertyCompanyVO> emptyResult = PageResult.of(
							Math.toIntExact(queryDTO.getCurrent()),
							Math.toIntExact(queryDTO.getSize()), 0L, Collections.emptyList());
					return Result.success(emptyResult);
				}

				// 用户有物业公司权限，按权限过滤
				queryWrapper.in("id", propertyCompanyIds);
				log.info("根据用户权限过滤物业公司，ID列表：{}", propertyCompanyIds);
			} else {
				// 超级管理员有所有权限
				log.info("超级管理员用户{}，可以查看所有物业公司", currentUserId);
			}

			// 排序
			queryWrapper.orderByDesc("create_time");

			// 分页查询
			Page<PropertyCompany> page = new Page<>(queryDTO.getCurrent(), queryDTO.getSize());
			IPage<PropertyCompany> result = this.page(page, queryWrapper);

			// 转换为VO
			List<PropertyCompanyVO> voList = result.getRecords().stream()
					.map(this::convertToVO)
					.collect(Collectors.toList());

			PageResult<PropertyCompanyVO> pageResult = PageResult.of(
					Math.toIntExact(result.getCurrent()),
					Math.toIntExact(result.getSize()), result.getTotal(), voList);

			log.info("查询物业公司列表成功，总数：{}", result.getTotal());
			return Result.success(pageResult);
		} catch (Exception e) {
			log.error("查询物业公司列表失败，参数：{}", queryDTO, e);
			return Result.fail("查询失败");
		}
	}

	@Override
	public Result<PropertyCompanyVO> getCurrentUserPropertyCompany() {
		try {
			log.info("获取当前用户的物业公司信息");
			Long userId = SecurityUtils.getCurrentUserId();
			List<PropertyCompany> userCompanies = getUserPropertyCompanies(userId);

			if (userCompanies.isEmpty()) {
				log.warn("用户未关联物业公司，用户ID：{}", userId);
				return Result.fail("用户未关联物业公司");
			}

			// 返回第一个关联的物业公司
			PropertyCompanyVO vo = convertToVO(userCompanies.get(0));
			log.info("获取当前用户物业公司信息成功，用户ID：{}", userId);
			return Result.success(vo);
		} catch (Exception e) {
			log.error("获取当前用户物业公司信息失败", e);
			return Result.fail("获取失败");
		}
	}

	@Override
	@GlobalTransactional
	@CacheEvict(value = { "propertyCompany", "propertyCompanyList", "propertyCompanyStats", "propertyInfo", "userPropertyCompany" }, allEntries = true)
	public Result<Void> updateCurrentUserPropertyCompany(PropertyCompanyDTO propertyCompanyDTO) {
		try {
			// 参数验证
			if (propertyCompanyDTO == null) {
				log.warn("更新当前用户物业公司信息失败，参数不能为空");
				return Result.fail("参数不能为空");
			}

			log.info("更新当前用户的物业公司信息，参数：{}", propertyCompanyDTO);
			Long userId = SecurityUtils.getCurrentUserId();
			List<PropertyCompany> userCompanies = getUserPropertyCompanies(userId);

			if (userCompanies.isEmpty()) {
				log.warn("用户未关联物业公司，用户ID：{}", userId);
				return Result.fail("用户未关联物业公司");
			}

			// 更新第一个关联的物业公司
			PropertyCompany existingCompany = userCompanies.get(0);
			BeanUtils.copyProperties(propertyCompanyDTO, existingCompany);
			existingCompany.setUpdateBy(userId);
			existingCompany.setUpdateTime(LocalDateTime.now());

			boolean success = this.updateById(existingCompany);
			if (success) {
				log.info("更新当前用户物业公司信息成功，用户ID：{}", userId);
				return Result.success();
			} else {
				log.warn("更新当前用户物业公司信息失败，用户ID：{}", userId);
				return Result.fail("更新失败");
			}
		} catch (Exception e) {
			log.error("更新当前用户物业公司信息失败，参数：{}", propertyCompanyDTO, e);
			return Result.fail("更新失败");
		}
	}

	@Override
	@GlobalTransactional
	@CacheEvict(value = { "propertyCompany", "propertyCompanyList", "propertyCompanyStats", "propertyInfo", "userPropertyCompany" }, allEntries = true)
	public Result<Void> updatePropertyCompany(Long id, PropertyCompanyDTO propertyCompanyDTO) {
		try {
			// 参数验证
			if (id == null) {
				log.warn("更新物业公司失败，ID不能为空");
				return Result.fail("物业公司ID不能为空");
			}
			if (propertyCompanyDTO == null) {
				log.warn("更新物业公司失败，参数不能为空");
				return Result.fail("参数不能为空");
			}

			log.info("更新物业公司，ID：{}，参数：{}", id, propertyCompanyDTO);
			
			// 检查物业公司是否存在
			PropertyCompany existingCompany = this.getById(id);
			if (existingCompany == null) {
				log.warn("物业公司不存在，ID：{}", id);
				return Result.fail("物业公司不存在");
			}

			// 检查公司编码是否已存在
			if (isCompanyCodeExists(propertyCompanyDTO.getCompanyCode(), id)) {
				log.warn("公司编码已存在，编码：{}，排除ID：{}", propertyCompanyDTO.getCompanyCode(), id);
				return Result.fail("公司编码已存在");
			}

			// 更新实体
			BeanUtils.copyProperties(propertyCompanyDTO, existingCompany);
			existingCompany.setUpdateBy(SecurityUtils.getCurrentUserId());
			existingCompany.setUpdateTime(LocalDateTime.now());

			boolean success = this.updateById(existingCompany);
			if (success) {
				log.info("更新物业公司成功，ID：{}", id);
				return Result.success();
			} else {
				log.warn("更新物业公司失败，ID：{}", id);
				return Result.fail("更新失败");
			}
		} catch (Exception e) {
			log.error("更新物业公司失败，ID：{}，参数：{}", id, propertyCompanyDTO, e);
			return Result.fail("更新失败");
		}
	}

	@Override
	public List<Object> getAvailableCommunities(Long propertyCompanyId, String searchKeyword) {
		try {
			// 参数验证
			if (propertyCompanyId == null) {
				log.warn("获取可分配的社区失败，物业公司ID不能为空");
				return Collections.emptyList();
			}

			log.info("获取可分配的社区，物业公司ID：{}，搜索关键词：{}", propertyCompanyId, searchKeyword);
			
			// 调用物业公司社区关联服务获取可分配的社区
			List<Object> communities = propertyCompanyCommunityService.getAvailableCommunities(propertyCompanyId, searchKeyword);
			log.info("获取可分配的社区成功，物业公司ID：{}，社区数量：{}", propertyCompanyId, communities.size());
			return communities;
		} catch (Exception e) {
			log.warn("获取可分配的社区失败，物业公司ID：{}", propertyCompanyId, e);
			return Collections.emptyList();
		}
	}

	@Override
	public List<PropertyCompanyVO> getPropertyCompanyListForSelect() {
		try {
			log.info("获取物业公司列表（用于下拉选择）");
			Long currentUserId = SecurityUtils.getCurrentUserId();

			QueryWrapper<PropertyCompany> queryWrapper = new QueryWrapper<>();
			queryWrapper.eq("status", SystemStatusEnum.ENABLED.getCode());
			queryWrapper.eq("audit_status", SystemStatusEnum.AUDIT_APPROVED.getCode());

			// 添加数据权限过滤
			if (!SecurityUtils.hasRole(RoleCodeEnum.SUPER_ADMIN.getCode())) {
				List<Long> propertyCompanyIds = permissionCacheService.getCurrentUserPropertyCompanyIds(currentUserId);
				if (propertyCompanyIds != null && !propertyCompanyIds.isEmpty()) {
					queryWrapper.in("id", propertyCompanyIds);
				} else {
					// 用户没有任何物业公司权限，返回空列表
					log.warn("用户{}没有物业公司权限，返回空列表", currentUserId);
					return Collections.emptyList();
				}
			}

			queryWrapper.orderByAsc("company_name");

			List<PropertyCompany> companies = this.list(queryWrapper);
			List<PropertyCompanyVO> result = companies.stream().map(this::convertToVO).collect(Collectors.toList());
			log.info("获取物业公司列表成功，数量：{}", result.size());
			return result;
		} catch (Exception e) {
			log.warn("获取物业公司列表失败", e);
			return Collections.emptyList();
		}
	}

	@Override
	public List<Object> getAssignedCommunities(Long propertyCompanyId, String searchKeyword) {
		try {
			// 参数验证
			if (propertyCompanyId == null) {
				log.warn("获取物业公司已分配的社区失败，物业公司ID不能为空");
				return Collections.emptyList();
			}

			log.info("获取物业公司已分配的社区，物业公司ID：{}，搜索关键词：{}", propertyCompanyId, searchKeyword);
			
			// 调用物业公司社区关联服务获取已分配的社区
			List<PropertyCompanyCommunity> communities = propertyCompanyCommunityService
					.getPropertyCompanyCommunities(propertyCompanyId);

			List<Map<String, Object>> assignedCommunities = new ArrayList<>();

			for (PropertyCompanyCommunity community : communities) {
				Map<String, Object> communityMap = buildCommunityMap(community);
				assignedCommunities.add(communityMap);
			}

			// 如果有搜索关键词，进行过滤
			if (StringUtils.hasText(searchKeyword)) {
				assignedCommunities = filterCommunitiesByKeyword(assignedCommunities, searchKeyword);
			}

			log.info("获取物业公司已分配的社区成功，物业公司ID：{}，社区数量：{}", propertyCompanyId, assignedCommunities.size());
			return new ArrayList<>(assignedCommunities);

		} catch (Exception e) {
			log.warn("获取物业公司已分配的社区失败，物业公司ID：{}", propertyCompanyId, e);
			return Collections.emptyList();
		}
	}

	@Override
	@GlobalTransactional
	@CacheEvict(value = { "propertyCompany", "propertyCompanyList", "propertyCompanyStats", "propertyInfo", "userPropertyCompany" }, allEntries = true)
	public Result<Void> deletePropertyCompany(Long id) {
		try {
			// 参数验证
			if (id == null) {
				log.warn("删除物业公司失败，ID不能为空");
				return Result.fail("物业公司ID不能为空");
			}

			log.info("删除物业公司，ID：{}", id);
			
			// 检查物业公司是否存在
			PropertyCompany propertyCompany = this.getById(id);
			if (propertyCompany == null) {
				log.warn("物业公司不存在，ID：{}", id);
				return Result.fail("物业公司不存在");
			}

			// 逻辑删除
			boolean success = this.removeById(id);
			if (success) {
				log.info("删除物业公司成功，ID：{}", id);
				return Result.success();
			} else {
				log.warn("删除物业公司失败，ID：{}", id);
				return Result.fail("删除失败");
			}
		} catch (Exception e) {
			log.error("删除物业公司失败，ID：{}", id, e);
			return Result.fail("删除失败");
		}
	}

	@Override
	@CacheEvict(value = { "propertyCompany", "propertyCompanyList", "propertyCompanyStats", "propertyInfo", "userPropertyCompany" }, allEntries = true)
	public Result<Void> auditPropertyCompany(Long id, PropertyCompanyAuditDTO auditDTO) {
		try {
			// 参数验证
			if (id == null) {
				log.warn("审核物业公司失败，ID不能为空");
				return Result.fail("物业公司ID不能为空");
			}
			if (auditDTO == null) {
				log.warn("审核物业公司失败，审核参数不能为空");
				return Result.fail("审核参数不能为空");
			}

			log.info("审核物业公司，ID：{}，参数：{}", id, auditDTO);
			
			// 检查权限（只有超级管理员可以审核）
			DataScopeInfo dataScopeInfo = dataScopeService.getCurrentUserDataScope();
			if (!dataScopeInfo.isSuperAdmin()) {
				log.warn("审核物业公司失败，权限不足，用户ID：{}", SecurityUtils.getCurrentUserId());
				return Result.fail("权限不足");
			}

			// 检查物业公司是否存在
			PropertyCompany propertyCompany = this.getById(id);
			if (propertyCompany == null) {
				log.warn("物业公司不存在，ID：{}", id);
				return Result.fail("物业公司不存在");
			}

			// 更新审核信息
			updateAuditInfo(propertyCompany, auditDTO);

			boolean success = this.updateById(propertyCompany);
			if (success) {
				log.info("审核物业公司成功，ID：{}", id);
				
				// 如果审核通过，处理联系人用户
				if (SystemStatusEnum.ENABLED.getCode().equals(propertyCompany.getStatus())) {
					handleContactUserAfterApproval(propertyCompany);
				}
				
				return Result.success();
			} else {
				log.warn("审核物业公司失败，ID：{}", id);
				return Result.fail("审核失败");
			}
		} catch (Exception e) {
			log.error("审核物业公司失败，ID：{}，参数：{}", id, auditDTO, e);
			return Result.fail("审核失败");
		}
	}

	@Override
	@GlobalTransactional
	public Result<String> assignCommunitiesToPropertyCompany(Long propertyCompanyId, List<Long> communityIds) {
		try {
			// 参数验证
			if (propertyCompanyId == null) {
				log.warn("为物业公司分配社区失败，物业公司ID不能为空");
				return Result.fail("物业公司ID不能为空");
			}
			if (communityIds == null || communityIds.isEmpty()) {
				log.warn("为物业公司分配社区失败，社区ID列表不能为空");
				return Result.fail("社区ID列表不能为空");
			}

			log.info("为物业公司分配社区，物业公司ID：{}，社区ID列表：{}", propertyCompanyId, communityIds);
			
			// 只有超级管理员有分配权限
			DataScopeInfo dataScopeInfo = dataScopeService.getCurrentUserDataScope();
			if (!dataScopeInfo.isSuperAdmin()) {
				log.warn("为物业公司分配社区失败，权限不足，用户ID：{}", SecurityUtils.getCurrentUserId());
				return Result.fail("权限不足");
			}

			// 调用物业公司社区关联服务进行分配
			Result<String> result = propertyCompanyCommunityService.assignCommunitiesToPropertyCompany(propertyCompanyId, communityIds);
			log.info("为物业公司分配社区完成，物业公司ID：{}，结果：{}", propertyCompanyId, result.isSuccess());
			return result;
		} catch (Exception e) {
			log.error("为物业公司分配社区失败，物业公司ID：{}，社区ID列表：{}", propertyCompanyId, communityIds, e);
			return Result.fail("分配失败");
		}
	}

	@Override
	@GlobalTransactional
	@CacheEvict(value = { "propertyCompany", "propertyCompanyList", "propertyCompanyStats", "propertyInfo", "userPropertyCompany" }, allEntries = true)
	public Result<Void> createPropertyCompany(PropertyCompanyDTO propertyCompanyDTO) {
		try {
			// 参数验证
			if (propertyCompanyDTO == null) {
				log.warn("新增物业公司失败，参数不能为空");
				return Result.fail("参数不能为空");
			}
			if (!StringUtils.hasText(propertyCompanyDTO.getCompanyCode())) {
				log.warn("新增物业公司失败，公司编码不能为空");
				return Result.fail("公司编码不能为空");
			}

			log.info("新增物业公司，参数：{}", propertyCompanyDTO);
			
			// 检查公司编码是否已存在
			if (isCompanyCodeExists(propertyCompanyDTO.getCompanyCode(), null)) {
				log.warn("新增物业公司失败，公司编码已存在：{}", propertyCompanyDTO.getCompanyCode());
				return Result.fail("公司编码已存在");
			}

			// 转换为实体
			PropertyCompany propertyCompany = new PropertyCompany();
			BeanUtils.copyProperties(propertyCompanyDTO, propertyCompany);

			// 设置默认值
			propertyCompany.setStatus(SystemStatusEnum.DISABLED.getCode());
			propertyCompany.setAuditStatus(SystemStatusEnum.AUDIT_PENDING.getCode()); // 待审核
			propertyCompany.setCreateBy(SecurityUtils.getCurrentUserId());
			propertyCompany.setCreateTime(LocalDateTime.now());

			boolean success = this.save(propertyCompany);
			if (success) {
				log.info("新增物业公司成功，ID：{}", propertyCompany.getId());
				return Result.success();
			} else {
				log.warn("新增物业公司失败");
				return Result.fail("新增失败");
			}
		} catch (Exception e) {
			log.error("新增物业公司失败，参数：{}", propertyCompanyDTO, e);
			return Result.fail("新增失败");
		}
	}
	
	@Override
	@GlobalTransactional
	@CacheEvict(value = { "propertyCompany", "propertyCompanyList", "propertyCompanyStats", "propertyInfo", "userPropertyCompany" }, allEntries = true)
	public Result<Void> registerPropertyCompany(PropertyCompanyDTO propertyCompanyDTO) {
		try {
			// 参数验证
			if (propertyCompanyDTO == null) {
				log.warn("物业公司注册失败，参数不能为空");
				return Result.fail("参数不能为空");
			}

			// 验证必填字段
			if (!StringUtils.hasText(propertyCompanyDTO.getContactPerson())) {
				log.warn("物业公司注册失败，联系人不能为空");
				return Result.fail("联系人不能为空");
			}
			if (!StringUtils.hasText(propertyCompanyDTO.getContactPhone())) {
				log.warn("物业公司注册失败，联系电话不能为空");
				return Result.fail("联系电话不能为空");
			}

			log.info("物业公司注册，参数：{}", propertyCompanyDTO);
			
			// 1. 按联系人和联系电话组合查询用户
			UserDTO existsUser = findUserByContactInfo(propertyCompanyDTO.getContactPerson(), propertyCompanyDTO.getContactPhone());
			
			// 2. 如果按组合查询不到用户，尝试按联系电话单独查询
			if (existsUser == null) {
				UserDTO phoneUser = userFeignService.getUserByPhone(propertyCompanyDTO.getContactPhone());
				if (phoneUser != null) {
					log.warn("物业公司注册失败，联系电话已被其他用户使用：{}", propertyCompanyDTO.getContactPhone());
					return Result.fail("此联系电话已有其他用户使用");
				}
			}
			
			// 自动生成公司编码
			String companyCode = generateUniqueCompanyCode();
			propertyCompanyDTO.setCompanyCode(companyCode);
			log.info("自动生成公司编码：{}", companyCode);

			// 转换为实体
			PropertyCompany propertyCompany = new PropertyCompany();
			BeanUtils.copyProperties(propertyCompanyDTO, propertyCompany);

			// 设置注册时的默认值
			propertyCompany.setStatus(SystemStatusEnum.DISABLED.getCode()); // 状态为禁用
			propertyCompany.setAuditStatus(SystemStatusEnum.AUDIT_PENDING.getCode()); // 审核状态为待审核
			propertyCompany.setCreateTime(LocalDateTime.now());
			propertyCompany.setUpdateTime(LocalDateTime.now());
			propertyCompany.setDeleted(SystemStatusEnum.NOT_DELETED.getCode());
			propertyCompany.setVersion(SystemStatusEnum.ENABLED.getCode());
			// 注册时不需要设置createBy，因为这是公开注册接口

			boolean success = this.save(propertyCompany);
			if (success) {
				log.info("物业公司注册成功，ID：{}，公司编码：{}", propertyCompany.getId(), companyCode);
				
				// 3. 为公司注册完成后，默认为物业公司关联一个用户
				associateUserWithPropertyCompany(propertyCompany.getId(), existsUser, propertyCompanyDTO);
				
				return Result.success();
			} else {
				log.warn("物业公司注册失败");
				return Result.fail("注册失败");
			}
		} catch (Exception e) {
			log.error("物业公司注册失败，参数：{}", propertyCompanyDTO, e);
			return Result.fail("注册失败");
		}
	}

	@Override
	public boolean hasViewPermission(Long userId) {
		try {
			// 参数验证
			if (userId == null) {
				log.warn("用户ID为空，权限检查失败");
				return false;
			}

			log.info("开始检查用户 {} 的物业公司查看权限", userId);

			// 检查是否为超级管理员
			DataScopeInfo dataScopeInfo = dataScopeService.getCurrentUserDataScope();
			boolean isSuperAdmin = dataScopeInfo.isSuperAdmin();
			log.info("用户 {} 超级管理员检查结果：{}", userId, isSuperAdmin);

			if (isSuperAdmin) {
				log.info("用户 {} 是超级管理员，拥有所有物业公司权限", userId);
				return true;
			}

			// 检查用户是否关联了物业公司
			List<PropertyCompany> propertyCompanies = getUserPropertyCompanies(userId);
			boolean hasPermission = !propertyCompanies.isEmpty();
			log.info("用户 {} 物业公司权限检查结果：{}，关联物业公司数量：{}", userId, hasPermission, propertyCompanies.size());
			return hasPermission;
		} catch (Exception e) {
			log.warn("检查用户物业公司查看权限失败，用户ID：{}", userId, e);
			return false;
		}
	}

	@Override
	public boolean hasViewPermission(Long userId, Long propertyCompanyId) {
		try {
			// 参数验证
			if (userId == null || propertyCompanyId == null) {
				log.warn("检查用户物业公司查看权限失败，用户ID或物业公司ID为空");
				return false;
			}

			log.info("检查用户{}对物业公司{}的查看权限", userId, propertyCompanyId);

			// 检查是否为超级管理员
			DataScopeInfo dataScopeInfo = dataScopeService.getCurrentUserDataScope();
			if (dataScopeInfo.isSuperAdmin()) {
				log.info("用户{}是超级管理员，拥有所有物业公司权限", userId);
				return true;
			}

			// 检查用户是否有该物业公司的权限
			List<PropertyCompany> propertyCompanies = getUserPropertyCompanies(userId);
			boolean hasPermission = propertyCompanies.stream().anyMatch(company -> company.getId().equals(propertyCompanyId));
			log.info("用户{}对物业公司{}的查看权限检查结果：{}", userId, propertyCompanyId, hasPermission);
			return hasPermission;
		} catch (Exception e) {
			log.warn("检查用户物业公司查看权限失败，用户ID：{}，物业公司ID：{}", userId, propertyCompanyId, e);
			return false;
		}
	}

	@Override
	public boolean hasAssignPermission(Long userId, Long propertyCompanyId) {
		try {
			// 参数验证
			if (userId == null || propertyCompanyId == null) {
				log.warn("检查用户分配权限失败，用户ID或物业公司ID为空");
				return false;
			}

			log.info("检查用户分配权限，用户ID：{}，物业公司ID：{}", userId, propertyCompanyId);

			// 超级管理员拥有所有权限
			DataScopeInfo dataScopeInfo = dataScopeService.getCurrentUserDataScope();
			if (dataScopeInfo.isSuperAdmin()) {
				log.info("用户{}是超级管理员，拥有分配权限", userId);
				return true;
			}

			// 物业公司管理员拥有本公司分配权限
			boolean hasPropertyCompanyPermission = permissionCacheService.hasPropertyCompanyPermission(userId, propertyCompanyId);
			log.info("用户{}物业公司权限检查结果：{}", userId, hasPropertyCompanyPermission);

			return hasPropertyCompanyPermission;
		} catch (Exception e) {
			log.warn("检查用户分配权限失败，用户ID：{}，物业公司ID：{}", userId, propertyCompanyId, e);
			return false;
		}
	}

	@Override
	public PropertyCompany getByCompanyCode(String companyCode) {
		try {
			// 参数验证
			if (!StringUtils.hasText(companyCode)) {
				log.warn("根据公司编码查询物业公司失败，公司编码不能为空");
				return null;
			}

			log.info("根据公司编码查询物业公司，公司编码：{}", companyCode);
			QueryWrapper<PropertyCompany> queryWrapper = new QueryWrapper<>();
			queryWrapper.eq("company_code", companyCode);
			PropertyCompany result = this.getOne(queryWrapper);
			log.info("根据公司编码查询物业公司完成，公司编码：{}，结果：{}", companyCode, result != null ? "找到" : "未找到");
			return result;
		} catch (Exception e) {
			log.warn("根据公司编码查询物业公司失败，公司编码：{}", companyCode, e);
			return null;
		}
	}

	@Override
	public boolean hasPropertyCompanyPermission(Long userId, Long propertyCompanyId) {
		try {
			// 参数验证
			if (userId == null || propertyCompanyId == null) {
				log.warn("检查用户物业公司权限失败，用户ID或物业公司ID为空");
				return false;
			}

			log.info("检查用户是否有物业公司权限，用户ID：{}，物业公司ID：{}", userId, propertyCompanyId);
			
			// 检查是否为超级管理员
			DataScopeInfo dataScopeInfo = dataScopeService.getCurrentUserDataScope();
			if (dataScopeInfo.isSuperAdmin()) {
				log.info("用户{}是超级管理员，拥有所有物业公司权限", userId);
				return true;
			}

			// 检查用户是否有该物业公司的权限
			List<PropertyCompany> propertyCompanies = getUserPropertyCompanies(userId);
			boolean hasPermission = propertyCompanies.stream().anyMatch(company -> company.getId().equals(propertyCompanyId));
			log.info("用户{}对物业公司{}的权限检查结果：{}", userId, propertyCompanyId, hasPermission);
			return hasPermission;
		} catch (Exception e) {
			log.warn("检查用户物业公司权限失败，用户ID：{}，物业公司ID：{}", userId, propertyCompanyId, e);
			return false;
		}
	}

	@Override
	public List<PropertyCompany> getUserPropertyCompanies(Long userId) {
		try {
			// 参数验证
			if (userId == null) {
				log.warn("获取用户关联的物业公司列表失败，用户ID不能为空");
				return Collections.emptyList();
			}

			log.info("获取用户关联的物业公司列表，用户ID：{}", userId);
			List<Long> propertyCompanyIds = dataScopeService.getUserPropertyCompanyIds(userId);

			if (propertyCompanyIds.isEmpty()) {
				log.info("用户{}没有关联的物业公司", userId);
				return Collections.emptyList();
			}

			QueryWrapper<PropertyCompany> queryWrapper = new QueryWrapper<>();
			queryWrapper.in("id", propertyCompanyIds);
			List<PropertyCompany> result = this.list(queryWrapper);
			log.info("获取用户关联的物业公司列表成功，用户ID：{}，物业公司数量：{}", userId, result.size());
			return result;
		} catch (Exception e) {
			log.warn("获取用户关联的物业公司列表失败，用户ID：{}", userId, e);
			return Collections.emptyList();
		}
	}


	@Override
	public boolean isCompanyCodeExists(String companyCode, Long excludeId) {
		try {
			// 参数验证
			if (!StringUtils.hasText(companyCode)) {
				log.warn("检查公司编码是否存在失败，公司编码不能为空");
				return false;
			}

			QueryWrapper<PropertyCompany> queryWrapper = new QueryWrapper<>();
			queryWrapper.eq("company_code", companyCode);

			if (excludeId != null) {
				queryWrapper.ne("id", excludeId);
			}

			boolean exists = this.count(queryWrapper) > 0;
			log.info("检查公司编码是否存在，编码：{}，排除ID：{}，结果：{}", companyCode, excludeId, exists);
			return exists;
		} catch (Exception e) {
			log.warn("检查公司编码是否存在失败，编码：{}，排除ID：{}", companyCode, excludeId, e);
			return false;
		}
	}

	/**
	 * 转换为VO对象
	 */
	private PropertyCompanyVO convertToVO(PropertyCompany propertyCompany) {
		PropertyCompanyVO vo = new PropertyCompanyVO();
		BeanUtils.copyProperties(propertyCompany, vo);

		// 设置状态名称
		vo.setStatusName(getStatusName(propertyCompany.getStatus()));
		vo.setAuditStatusName(getAuditStatusName(propertyCompany.getAuditStatus()));

		return vo;
	}

	/**
	 * 获取状态名称
	 */
	private String getStatusName(Integer status) {
		if (status == null)
			return "";
		switch (status) {
		case 0:
			return "禁用";
		case 1:
			return "启用";
		default:
			return "未知";
		}
	}

	/**
	 * 获取审核状态名称
	 */
	private String getAuditStatusName(Integer auditStatus) {
		if (auditStatus == null) {
			return "";
		}
		switch (auditStatus) {
			case 0:
				return "待审核";
			case 1:
				return "审核通过";
			case 2:
				return "审核拒绝";
			case 3:
				return "审核拒绝";
			default:
				return "未知";
		}
	}

	/**
	 * 构建查询条件
	 */
	private QueryWrapper<PropertyCompany> buildQueryWrapper(PropertyCompanyQueryDTO queryDTO) {
		QueryWrapper<PropertyCompany> queryWrapper = new QueryWrapper<>();

		// 添加查询条件
		if (StringUtils.hasText(queryDTO.getCompanyName())) {
			queryWrapper.like("company_name", queryDTO.getCompanyName());
		}
		if (StringUtils.hasText(queryDTO.getCompanyCode())) {
			queryWrapper.like("company_code", queryDTO.getCompanyCode());
		}
		if (StringUtils.hasText(queryDTO.getContactPerson())) {
			queryWrapper.like("contact_person", queryDTO.getContactPerson());
		}
		if (StringUtils.hasText(queryDTO.getContactPhone())) {
			queryWrapper.like("contact_phone", queryDTO.getContactPhone());
		}
		if (StringUtils.hasText(queryDTO.getQualificationLevel())) {
			queryWrapper.eq("qualification_level", queryDTO.getQualificationLevel());
		}
		if (queryDTO.getStatus() != null) {
			queryWrapper.eq("status", queryDTO.getStatus());
		}
		if (queryDTO.getAuditStatus() != null) {
			queryWrapper.eq("audit_status", queryDTO.getAuditStatus());
		}

		return queryWrapper;
	}

	/**
	 * 构建社区信息Map
	 */
	private Map<String, Object> buildCommunityMap(PropertyCompanyCommunity community) {
		Map<String, Object> communityMap = new HashMap<>();
		communityMap.put("id", community.getCommunityId());

		// 调用区域服务获取社区详细信息
		try {
			com.smart.community.feign.region.dto.CommunityInfoDTO communityInfo = 
					regionDataFeignClient.getCommunityById(community.getCommunityId());

			if (communityInfo != null) {
				communityMap.put("communityName", communityInfo.getCommunityName());
				communityMap.put("communityCode", communityInfo.getCommunityCode());
				communityMap.put("address", communityInfo.getAddress() != null ? communityInfo.getAddress() : "");

				// 获取区域完整路径信息
				List<RegionDTO> pathResultData = regionDataFeignClient.getRegionPath(communityInfo.getRegionId());
				if (pathResultData != null && !pathResultData.isEmpty()) {
					String regionFullName = pathResultData.stream().map(RegionDTO::getRegionName)
							.collect(Collectors.joining(" / "));
					communityMap.put("regionFullName", regionFullName);
				} else {
					communityMap.put("regionFullName", communityInfo.getCommunityName());
				}
			} else {
				// Feign调用失败，使用基本信息而不是返回null
				log.warn("区域服务返回null，社区ID：{}，使用基本信息", community.getCommunityId());
				communityMap.put("communityName", "社区" + community.getCommunityId());
				communityMap.put("communityCode", "COMM" + community.getCommunityId());
				communityMap.put("address", "地址信息");
				communityMap.put("regionFullName", "区域信息");
			}
		} catch (Exception e) {
			// Feign调用异常，使用基本信息而不是返回null
			log.warn("获取社区详细信息失败，社区ID：{}，使用基本信息，错误：{}", community.getCommunityId(), e.getMessage());
			communityMap.put("communityName", "社区" + community.getCommunityId());
			communityMap.put("communityCode", "COMM" + community.getCommunityId());
			communityMap.put("address", "地址信息");
			communityMap.put("regionFullName", "区域信息");
		}

		return communityMap;
	}


	/**
	 * 根据关键词过滤社区
	 */
	private List<Map<String, Object>> filterCommunitiesByKeyword(List<Map<String, Object>> communities, String searchKeyword) {
		return communities.stream().filter(communityMap -> {
			String communityName = (String) communityMap.get("communityName");
			String regionFullName = (String) communityMap.get("regionFullName");
			return (communityName != null && communityName.toLowerCase().contains(searchKeyword.toLowerCase()))
					|| (regionFullName != null && regionFullName.toLowerCase().contains(searchKeyword.toLowerCase()));
		}).collect(Collectors.toList());
	}

	/**
	 * 更新审核信息
	 */
	private void updateAuditInfo(PropertyCompany propertyCompany, PropertyCompanyAuditDTO auditDTO) {
		propertyCompany.setAuditStatus(auditDTO.getAuditStatus());
		propertyCompany.setAuditRemark(auditDTO.getAuditRemark());
		propertyCompany.setAuditBy(SecurityUtils.getCurrentUserId());
		propertyCompany.setAuditTime(LocalDateTime.now());

		// 如果审核通过，更新状态为启用
		if (SystemStatusEnum.AUDIT_APPROVED.getCode().equals(auditDTO.getAuditStatus())) {
			propertyCompany.setStatus(SystemStatusEnum.ENABLED.getCode());
		} else if (SystemStatusEnum.AUDIT_REJECTED.getCode().equals(auditDTO.getAuditStatus())) {
			propertyCompany.setStatus(SystemStatusEnum.DISABLED.getCode());
		}
	}

	/**
	 * 审核通过后处理联系人用户
	 */
	private void handleContactUserAfterApproval(PropertyCompany propertyCompany) {
		try {
			// 获取物业公司联系人电话
			String contactPhone = propertyCompany.getContactPhone();
			if (!StringUtils.hasText(contactPhone)) {
				log.warn("物业公司联系人电话为空，跳过用户处理，物业公司ID：{}", propertyCompany.getId());
				return;
			}

			log.info("开始处理物业公司联系人用户，联系人电话：{}", contactPhone);
			
			// 根据联系人电话查询用户
			UserDTO existingUser = null;
			try {
				existingUser = userFeignService.getUserByPhone(contactPhone);
			} catch (Exception feignException) {
				log.warn("调用用户服务查询用户失败，联系人电话：{}，错误：{}", contactPhone, feignException.getMessage());
				// 继续执行，尝试创建新用户
			}
			
			if (existingUser != null) {
				// 用户已存在，更新用户类型为物业管理员
				updateExistingUserToPropertyAdmin(existingUser, propertyCompany);
			} else {
				// 用户不存在，创建新用户
				createNewPropertyAdminUser(contactPhone, propertyCompany);
			}
		} catch (Exception e) {
			log.error("处理物业公司联系人用户时发生异常，物业公司ID：{}，异常信息：{}", propertyCompany.getId(), e.getMessage(), e);
			// 不抛出异常，避免影响审核流程
		}
	}

	/**
	 * 更新现有用户为物业管理员
	 */
	private void updateExistingUserToPropertyAdmin(UserDTO existingUser, PropertyCompany propertyCompany) {
		try {
			log.info("用户已存在，用户ID：{}，更新用户类型为物业管理员", existingUser.getId());
			existingUser.setUserType(RoleCodeEnum.PROPERTY_ADMIN.getCode());
			existingUser.setPropertyCompanyId(propertyCompany.getId());
			userFeignService.updateUser(existingUser);
			
			// 分配物业管理员角色（id=9）
			List<Long> roleIds = Arrays.asList(9L);
			userFeignService.assignUserRoles(existingUser.getId(), roleIds);
			log.info("已为用户分配物业管理员角色，用户ID：{}", existingUser.getId());

			// 更新用户和物业公司关联
			updateOrAddUserPropertyCompany(existingUser.getId(), propertyCompany.getId());
		} catch (Exception updateException) {
			log.warn("更新用户信息失败，用户ID：{}，错误：{}", existingUser.getId(), updateException.getMessage());
		}
	}

	/**
	 * 创建新的物业管理员用户
	 */
	private void createNewPropertyAdminUser(String contactPhone, PropertyCompany propertyCompany) {
		try {
			log.info("用户不存在，开始创建新用户，联系人电话：{}", contactPhone);
			
			// 创建用户DTO
			UserDTO newUser = new UserDTO();
			newUser.setUsername(contactPhone);
			newUser.setPhone(contactPhone);
			newUser.setRealName(propertyCompany.getContactPerson());
			newUser.setUserType(RoleCodeEnum.PROPERTY_ADMIN.getCode());
			newUser.setStatus(SystemStatusEnum.USER_NORMAL.getCode());
			newUser.setAuditStatus(SystemStatusEnum.AUDIT_APPROVED.getCode());
			newUser.setPropertyCompanyId(propertyCompany.getId());
			
			// 创建用户
			UserDTO createdUser = userFeignService.createUser(newUser);
			if (createdUser != null) {
				log.info("新用户创建成功，用户ID：{}", createdUser.getId());
				
				// 分配物业管理员角色（id=9）
				List<Long> roleIds = Arrays.asList(9L);
				userFeignService.assignUserRoles(createdUser.getId(), roleIds);
				log.info("已为新用户分配物业管理员角色，用户ID：{}", createdUser.getId());
				
				// 更新用户和物业公司关联
				updateOrAddUserPropertyCompany(createdUser.getId(), propertyCompany.getId());
			} else {
				log.warn("新用户创建失败，联系人电话：{}", contactPhone);
			}
		} catch (Exception createException) {
			log.warn("创建新用户失败，联系人电话：{}，错误：{}", contactPhone, createException.getMessage());
		}
	}

	/**
	 * 构建物业公司统计信息
	 */
	private Map<String, Object> buildPropertyCompanyStats(Long propertyCompanyId) {
		Map<String, Object> stats = new HashMap<>();

		// 1. 关联社区数
		List<PropertyCompanyCommunity> communities = propertyCompanyCommunityService
				.getPropertyCompanyCommunities(propertyCompanyId);
		stats.put("communityCount", communities.size());

		// 2. 服务房户数（根据关联社区→楼栋→单元→房户的层级关系计算）
		long householdCount = 0;
		if (!communities.isEmpty()) {
			List<Long> communityIds = communities.stream().map(PropertyCompanyCommunity::getCommunityId)
					.collect(Collectors.toList());

			// 调用区域服务获取房户数量
			try {
				// 这里应该调用区域服务的Feign接口获取房户统计
				// 暂时使用模拟数据
				householdCount = communityIds.size() * 100; // 假设每个社区100户
			} catch (Exception e) {
				log.warn("获取房户统计失败，使用默认值", e);
				householdCount = 0;
			}
		}
		stats.put("householdCount", householdCount);

		// 3. 本月收入（暂时使用模拟数据）
		stats.put("monthlyIncome", 0);

		return stats;
	}

	@Override
	public Object getPropertyCompanyDetailStats(Long propertyCompanyId) {
		try {
			// 参数验证
			if (propertyCompanyId == null) {
				log.warn("获取物业公司详情统计信息失败，物业公司ID不能为空");
				throw new RuntimeException("物业公司ID不能为空");
			}

			log.info("获取物业公司详情统计信息，物业公司ID：{}", propertyCompanyId);
			
			// 检查物业公司是否存在
			PropertyCompany propertyCompany = this.getById(propertyCompanyId);
			if (propertyCompany == null) {
				log.warn("物业公司不存在，ID：{}", propertyCompanyId);
				throw new RuntimeException("物业公司不存在");
			}
//
//			// 检查权限
//			Long currentUserId = SecurityUtils.getCurrentUserId();
//			if (!hasViewPermission(currentUserId, propertyCompanyId)) {
//				log.warn("用户{}没有权限查看物业公司{}的统计信息", currentUserId, propertyCompanyId);
//				throw new RuntimeException("您没有权限查看该物业公司的统计信息");
//			}

			Map<String, Object> stats = buildPropertyCompanyStats(propertyCompanyId);
			log.info("获取物业公司详情统计信息成功，物业公司ID：{}，统计结果：{}", propertyCompanyId, stats);
			return stats;

		} catch (Exception e) {
			log.error("获取物业公司详情统计信息失败，物业公司ID：{}", propertyCompanyId, e);
			throw new RuntimeException("获取统计信息失败：" + e.getMessage());
		}
	}

	@Override
	@GlobalTransactional
	public void updateOrAddUserPropertyCompany(Long userId, Long propertyCompanyId) {
		try {
			// 参数验证
			if (userId == null || propertyCompanyId == null) {
				log.warn("更新或添加用户物业公司关联失败，用户ID或物业公司ID为空");
				return;
			}

			log.info("更新或添加用户物业公司关联，用户ID：{}，物业公司ID：{}", userId, propertyCompanyId);
			
			UserPropertyCompany upc = userPropertyCompanyMapper.selectByUserIdAndPropertyCompanyId(userId, propertyCompanyId);
			Long currentUserId = SecurityUtils.getCurrentUserId();
			LocalDateTime now = LocalDateTime.now();
			
			if (upc == null) {
				upc = new UserPropertyCompany();
				upc.setUserId(userId);
				upc.setCreateBy(currentUserId);
				upc.setCreateTime(now);
			}
			
			upc.setUpdateBy(currentUserId);
			upc.setUpdateTime(now);
			upc.setStatus(SystemStatusEnum.ENABLED.getCode());
			upc.setJoinDate(now.toLocalDate());
			upc.setPropertyCompanyId(propertyCompanyId);
			
			// 更新或插入
			if (upc.getId() == null) {
				userPropertyCompanyMapper.insert(upc);
				log.info("插入用户和物业公司关联成功，用户：{}，物业公司：{}", userId, propertyCompanyId);
			} else {
				userPropertyCompanyMapper.updateById(upc);
				log.info("更新用户和物业公司关联成功，用户：{}，物业公司：{}", userId, propertyCompanyId);
			}
		} catch (Exception e) {
			log.error("更新或添加用户物业公司关联失败，用户ID：{}，物业公司ID：{}", userId, propertyCompanyId, e);
			throw new RuntimeException("更新用户物业公司关联失败");
		}
	}

	/**
	 * 生成唯一的公司编码
	 * 
	 * 使用StringUtils.generateRandomString32()方法生成32位随机字符串
	 * 确保生成的编码在系统中唯一
	 * 
	 * @return 唯一的公司编码
	 */
	private String generateUniqueCompanyCode() {
		String companyCode;
		int maxAttempts = 10; // 最大尝试次数
		int attempts = 0;
		
		do {
			companyCode = com.smart.community.commons.utils.StringUtils.generateRandomString32();
			attempts++;
			
			// 检查编码是否已存在
			if (!isCompanyCodeExists(companyCode, null)) {
				log.info("生成唯一公司编码成功：{}，尝试次数：{}", companyCode, attempts);
				return companyCode;
			}
			
			log.warn("生成的公司编码已存在，重新生成：{}，尝试次数：{}", companyCode, attempts);
		} while (attempts < maxAttempts);
		
		// 如果达到最大尝试次数仍未生成唯一编码，抛出异常
		log.error("生成唯一公司编码失败，已达到最大尝试次数：{}", maxAttempts);
		throw new RuntimeException("生成唯一公司编码失败，请稍后重试");
	}
	
	/**
	 * 按联系人和联系电话查询用户
	 * 
	 * @param contactPerson 联系人
	 * @param contactPhone 联系电话
	 * @return 用户信息，如果未找到则返回null
	 */
	private UserDTO findUserByContactInfo(String contactPerson, String contactPhone) {
		try {
			if (!StringUtils.hasText(contactPerson) || !StringUtils.hasText(contactPhone)) {
				log.warn("联系人或联系电话为空，无法查询用户");
				return null;
			}
			
			log.info("按联系人和联系电话查询用户，联系人：{}，联系电话：{}", contactPerson, contactPhone);
			
			// 先尝试按联系电话查询
			UserDTO phoneUser = userFeignService.getUserByPhone(contactPhone);
			if (phoneUser != null) {
				// 如果找到用户，检查联系人是否匹配
				if (contactPerson.equals(phoneUser.getRealName())) {
					log.info("找到匹配的用户，用户ID：{}，姓名：{}，电话：{}", phoneUser.getId(), phoneUser.getRealName(), phoneUser.getPhone());
					return phoneUser;
				} else {
					log.info("联系电话匹配但联系人姓名不匹配，联系电话：{}，期望联系人：{}，实际姓名：{}", 
							contactPhone, contactPerson, phoneUser.getRealName());
					// 联系人姓名不匹配，返回null，让后续逻辑处理
					return null;
				}
			}
			
			log.info("未找到匹配的用户，联系人：{}，联系电话：{}", contactPerson, contactPhone);
			return null;
		} catch (Exception e) {
			log.error("按联系人和联系电话查询用户失败，联系人：{}，联系电话：{}", contactPerson, contactPhone, e);
			return null;
		}
	}
	
	/**
	 * 为物业公司关联用户
	 * 
	 * @param propertyCompanyId 物业公司ID
	 * @param existsUser 已存在的用户，如果为null则创建新用户
	 * @param propertyCompanyDTO 物业公司信息
	 * @throws RuntimeException 关联用户失败时抛出异常，中止主流程
	 */
	private void associateUserWithPropertyCompany(Long propertyCompanyId, UserDTO existsUser, PropertyCompanyDTO propertyCompanyDTO) {
		log.info("开始为物业公司关联用户，物业公司ID：{}，已存在用户：{}", propertyCompanyId, existsUser != null ? existsUser.getId() : "无");
		
		Long userId;
		
		if (existsUser != null) {
			// 使用已存在的用户
			userId = existsUser.getId();
			log.info("使用已存在的用户，用户ID：{}，姓名：{}", userId, existsUser.getRealName());
		} else {
			// 创建新用户
			userId = createNewUserForPropertyCompany(propertyCompanyDTO);
			log.info("创建新用户成功，用户ID：{}", userId);
		}
		
		// 为用户分配物业管理员角色
		assignPropertyAdminRole(userId);
		
		// 关联用户和物业公司
		associateUserWithCompany(userId, propertyCompanyId, propertyCompanyDTO);
		
		log.info("为物业公司关联用户完成，物业公司ID：{}，用户ID：{}", propertyCompanyId, userId);
	}
	
	/**
	 * 创建新用户
	 * 
	 * @param propertyCompanyDTO 物业公司信息
	 * @return 新用户ID
	 * @throws RuntimeException 创建用户失败时抛出异常
	 */
	private Long createNewUserForPropertyCompany(PropertyCompanyDTO propertyCompanyDTO) {
		log.info("开始创建新用户，联系人：{}，联系电话：{}", propertyCompanyDTO.getContactPerson(), propertyCompanyDTO.getContactPhone());
		
		// 构建用户信息
		UserDTO newUser = new UserDTO();
		newUser.setRealName(propertyCompanyDTO.getContactPerson());
		newUser.setPhone(propertyCompanyDTO.getContactPhone());
		newUser.setEmail(propertyCompanyDTO.getContactEmail());
		newUser.setUserType("PROPERTY_ADMIN"); // 设置为物业管理员类型
		newUser.setStatus(SystemStatusEnum.ENABLED.getCode()); // 启用状态
		
		// 生成用户名（使用联系电话）
		newUser.setUsername(propertyCompanyDTO.getContactPhone());
		
		// 设置默认密码（加密存储）
		newUser.setPassword(SecurityUtils.encryptPassword(propertyCompanyDTO.getContactPhone())); // 默认密码，建议后续要求用户修改
		
		// 调用用户服务创建用户
		UserDTO createdUser = userFeignService.createUser(newUser);
		if (createdUser == null || createdUser.getId() == null) {
			log.error("创建用户失败，用户服务返回空结果，联系人：{}，联系电话：{}", propertyCompanyDTO.getContactPerson(), propertyCompanyDTO.getContactPhone());
			throw new RuntimeException("创建用户失败：用户服务返回空结果");
		}
		
		log.info("创建新用户成功，用户ID：{}，用户名：{}，姓名：{}", createdUser.getId(), createdUser.getUsername(), createdUser.getRealName());
		return createdUser.getId();
	}
	
	/**
	 * 为用户分配物业管理员角色
	 * 
	 * @param userId 用户ID
	 * @throws RuntimeException 分配角色失败时抛出异常
	 */
	private void assignPropertyAdminRole(Long userId) {
		log.info("开始为用户分配物业管理员角色，用户ID：{}", userId);
		
		// 获取物业管理员角色ID
		Long propertyAdminRoleId = getPropertyAdminRoleId();
		if (propertyAdminRoleId == null) {
			log.error("未找到物业管理员角色，无法分配角色，用户ID：{}", userId);
			throw new RuntimeException("未找到物业管理员角色，无法分配角色");
		}
		
		// 分配角色
		List<Long> roleIds = Arrays.asList(propertyAdminRoleId);
		try {
			userFeignService.assignUserRoles(userId, roleIds);
			log.info("为用户分配物业管理员角色成功，用户ID：{}，角色ID：{}", userId, propertyAdminRoleId);
		} catch (Exception e) {
			log.error("调用用户服务分配角色失败，用户ID：{}，角色ID：{}", userId, propertyAdminRoleId, e);
			throw new RuntimeException("分配角色失败：" + e.getMessage());
		}
	}
	
	/**
	 * 获取物业管理员角色ID
	 * 
	 * @return 物业管理员角色ID
	 */
	private Long getPropertyAdminRoleId() {
		try {
			log.info("开始获取物业管理员角色ID");
			
			// 使用物业管理员角色代码获取角色ID
			Long roleId = userFeignService.getRoleIdByCode(RoleCodeEnum.PROPERTY_ADMIN.getCode());
			if (roleId != null) {
				log.info("获取物业管理员角色ID成功，角色ID：{}", roleId);
				return roleId;
			} else {
				log.warn("未找到物业管理员角色，角色代码：{}", RoleCodeEnum.PROPERTY_ADMIN.getCode());
				return null;
			}
		} catch (Exception e) {
			log.error("获取物业管理员角色ID失败，角色代码：{}", RoleCodeEnum.PROPERTY_ADMIN.getCode(), e);
			return null;
		}
	}
	
	/**
	 * 关联用户和物业公司
	 * 
	 * @param userId 用户ID
	 * @param propertyCompanyId 物业公司ID
	 * @param propertyCompanyDTO 物业公司信息
	 * @throws RuntimeException 关联失败时抛出异常
	 */
	private void associateUserWithCompany(Long userId, Long propertyCompanyId, PropertyCompanyDTO propertyCompanyDTO) {
		log.info("开始关联用户和物业公司，用户ID：{}，物业公司ID：{}", userId, propertyCompanyId);
		
		// 检查是否已存在关联
		UserPropertyCompany existingAssociation = userPropertyCompanyMapper.selectByUserIdAndPropertyCompanyId(userId, propertyCompanyId);
		if (existingAssociation != null) {
			log.info("用户和物业公司关联已存在，用户ID：{}，物业公司ID：{}", userId, propertyCompanyId);
			return;
		}
		
		// 创建新的关联
		UserPropertyCompany userPropertyCompany = new UserPropertyCompany();
		userPropertyCompany.setUserId(userId);
		userPropertyCompany.setPropertyCompanyId(propertyCompanyId);
		userPropertyCompany.setPosition("物业管理员"); // 默认职位
		userPropertyCompany.setDepartment("管理部"); // 默认部门
		userPropertyCompany.setStatus(SystemStatusEnum.ENABLED.getCode()); // 启用状态
		userPropertyCompany.setCreateTime(LocalDateTime.now());
		userPropertyCompany.setUpdateTime(LocalDateTime.now());
		
		// 保存关联
		int insertResult = userPropertyCompanyMapper.insert(userPropertyCompany);
		if (insertResult <= 0) {
			log.error("关联用户和物业公司失败，数据库插入失败，用户ID：{}，物业公司ID：{}", userId, propertyCompanyId);
			throw new RuntimeException("关联用户和物业公司失败：数据库插入失败");
		}
		
		log.info("关联用户和物业公司成功，用户ID：{}，物业公司ID：{}", userId, propertyCompanyId);
	}
}
